﻿#include <iostream>
using namespace std;
#include <vector>

//1.1继承的概念
//class Person
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
//	void identity()
//	{
//		cout << "void identity()" << _name << endl;
//	}
//protected:
//	string _name = "张三"; // 姓名 
//	string _address; // 地址 
//	string _tel; // 电话 
//	int _age = 18; // 年龄 
//};
//
//class Student : public Person//学生继承个人
//{
//public:
//	// 学习 
//	void study()
//	{
//		// ...
//	}
//protected:
//	int _stuid; // 学号 
//};
//
//class Teacher : public Person//老师继承个人
//{
//public:
//	// 授课 
//	void teaching()
//	{
//		//...
//	}
//protected:
//	string title; // 职称 
//};
//
//int main()
//{
//	Student s;
//	Teacher t;
//	s.identity();
//	t.identity();
//	return 0;
//}

//1.2.1继承的格式
//上述person是被继承的类，父类，基类
//student和teacher是继承person的类，子类，派生类
//public是继承方式
//
//1.2.2访问方式变化
//比较符合直觉，public(公共)继承，父类public和protected分别被子类继承
//				protect(保护)继承，父类上述两种类型被子类继承为protect成员
//				private(私有)继承，父类上述两种类型被子类继承为private成员
//父类的private成员不能被子类继承，仅父类私有
//可以间接调用，父类public写个函数调用父类的private成员，然后子类继承后调用父类的这个函数就可以间接使用父类的private成员

//1.3继承类模版
//namespace bit
//{
//	//template<class T>
//	//class vector
//	//{};
//	// stack和vector的关系，既符合is-a，也符合has-a 
//	template<class T>
//	class stack : public std::vector<T>
//	{
//	public:
//		void push(const T& x)
//		{
//			// 基类是类模板时，需要指定⼀下类域， 
//			// 否则编译报错:error C3861: “push_back”: 找不到标识符 
//			// 因为stack<int>实例化时，也实例化vector<int>了 
//			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到 
//			vector<T>::push_back(x);
//			//push_back(x);
//		}//*说的很清楚
//		void pop()
//		{
//			vector<T>::pop_back();
//		}
//		const T& top()
//		{
//			return vector<T>::back();
//		}
//		bool empty()
//		{
//			return vector<T>::empty();
//		}
//	};
//}
//int main()
//{
//	bit::stack<int> st;
//	st.push(1);
//	st.push(2);
//	st.push(3);
//	while (!st.empty())
//	{
//		cout << st.top() << " ";
//		st.pop();
//	}
//	return 0;
//}



//2.基类(父类)和派生类(子类)间的转换
//派生类对象可以赋值给基类的指针或引用
//这⾥有个形象的说法叫切⽚或者切割。寓意把派⽣类中基类那部分切出来，基类指针或引⽤指向的是派⽣类中切出来的基类那部分
//就是说只保留子类继承了父类的那部分


//3继承类中的作用域
//3.1隐藏规则
// //Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆 
//class Person
//{
//protected:
//	string _name = "小李子"; // 姓名 
//	int _num = 111; // ⾝份证号 
//};
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << " 姓名:" << _name << endl;
//		cout << " 身份证号:" << Person::_num << endl;
//		cout << " 学号:" << _num << endl;
//	}
//protected:
//	int _num = 999; // 学号 
//};
//int main()
//{
//	Student s1;
//	s1.Print();
//
//	return 0;
//};
//同名即隐藏：只要派生类成员与基类成员名称相同（无论参数列表、返回值是否相同），基类成员就会被隐藏。
//作用域隔离：基类和派生类属于不同作用域，派生类作用域嵌套在基类作用域之外，同名成员会优先使用派生类的。
//需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//int main()
//{
//	B b;
//	b.fun(10);
//	b.A::fun();
//
//	return 0;
//}


//4.派生类的默认成员函数
//4.1 4个常见默认成员函数
//class Person
//{
//public:
//	Person(const char* name = "peter")//构造
//		: _name(name)
//	{
//		cout << "Person()" << endl;
//	}
//
//	Person(const Person& p)//拷贝构造
//		: _name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//
//	Person& operator=(const Person& p)//赋值运算符重载
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//
//		return *this;
//	}
//
//	~Person()//析构
//	{
//		cout << "~Person()" << endl;
//	}
//protected:
//	string _name; // 姓名 
//};
//class Student : public Person
//{
//public:
//	Student(const char* name, int num)//拷贝
//		: Person(name)//子类赋值给父类，切片
//		, _num(num)
//	{
//		cout << "Student()" << endl;
//	}
//
//	Student(const Student& s)//拷贝构造
//		: Person(s)
//		, _num(s._num)
//	{
//		cout << "Student(const Student& s)" << endl;
//	}
//
//	Student& operator = (const Student& s)//赋值运算符重载
//	{
//		cout << "Student& operator= (const Student& s)" << endl;
//		if (this != &s)
//		{
//			// 构成隐藏，所以需要显⽰调⽤ 
//			Person::operator =(s);
//			//派⽣类的operator = 必须要调⽤基类的operator = 完成基类的复制。需要注意的是派⽣类的
//			//operator=隐藏了基类的operator = ，所以显⽰调⽤基类的operator = ，需要指定基类作⽤域
//			_num = s._num;
//		}
//		return *this;
//	}
//
//	~Student()//析构
//	{
//		cout << "~Student()" << endl;
//	}
//protected:
//	int _num; //学号 
//};
//int main()
//{
//	Student s1("jack", 18);
//	Student s2(s1);
//	Student s3("rose", 17);
//	s1 = s3;
//
//	return 0;
//}

//4.2实现一个不能被继承的类
//class person final  ,关键词final,意为最终类 
//基类(父类)构造函数私有


//5.继承和友元
//class Student;
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);
//protected:
//	string _name; // 姓名 
//};
//class Student : public Person
//{
//protected:
//	int _stuNum; // 学号 
//};
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}
//int main()
//{
//	Person p;
//	Student s;
//	// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员 
//	// 解决⽅案：Display也变成Student 的友元即可 
//	Display(p, s);
//
//	return 0;
//}
//友元关系不能被继承，要使用在派生类中加个友元函数


//6.继承和静态成员
//基类定义了static静态成员，则整个继承体系⾥⾯只有⼀个这样的成员。⽆论派⽣出多少个派⽣类，都只有⼀个static成员实例
//class Person
//{
//public:
//	string _name;
//	static int _count;
//};
//int Person::_count = 0;
//class Student : public Person{};
//int main()
//{
//	Person p;
//	Student s;
//
//	//非静态成员地址不同，父子类不共用份
//	cout << &p._name << " " << &s._name << endl;
//	//静态成员地址相同，父子类共用一份
//	cout << &p._count << " " << &s._count << endl;
//	//静态成员公有，基类、派生类都可以指定类域访问
//	cout << Person::_count << " " << Student::_count << endl;
//
//	return 0;
//}


//7.多继承及其菱形继承问题
//7.1继承模型
//单继承：只有一个直接父类
//多继承：多个直接父类
//菱形继承：A被B、C继承，B、C被D继承。菱形继承（也称为钻石继承）是一种特殊的多重继承场景，
//		    其结构类似菱形，可能导致数据冗余和二义性问题。
//#数据冗余：当 B 和 C 都以普通方式（非虚继承）继承 A 时，A 中的成员变量会被 B 和 C 各自复制一份。
//			 当 D 继承 B 和 C 时，D 的对象中会同时包含 B 继承的 A 成员和 C 继承的 A 成员，
//			 导致 A 的成员在 D 中存在两份拷贝，这就是数据冗余。
//#二义性：由于 D 中包含 A 成员的两份拷贝，当通过 D 的对象访问 A 中的成员时，
//		   编译器无法确定应该访问哪一份（来自 B 的还是来自 C 的），从而产生编译错误，这就是二义性。

//7.2虚继承,关键词virtual
//class Person
//{
//public:
//	string _name;
//};
//class Student : virtual public Person
//{
//protected:
//	int _num;
//};
//class Teacher : virtual public Person
//{
//protected:
//	int _id;
//};
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse;
//};
//int main()
//{
//	Assistant a;
//	a._name = "peter";
//
//	return 0;
//}
//虚继承的核心作用就是让所有通过虚继承方式派生的类，共享同一个基类实例，而不是各自拥有独立的拷贝

//7.3多继承中指针偏移问题
//class Base1 { public: int _b1; };
//class Base2 { public: int _b2; };
//class Derive : public Base1, public Base2 { public: int _d; };
//int main()
//{
//	Derive d;
//	Base1* p1 = &d;
//	Base2* p2 = &d;
//	Derive* p3 = &d;
//
//	return 0;
//}
//Derive 对象 d 内存布局中，Base1 部分在最开始，p1 指向 Base1 起始地址，p3 是 Derive* 也指向起始地址，
//所以 p1 == p3；Base2 部分在 Base1 之后，p2 指向 Base2 起始地址，与 p1、p3 不同，即 p1 == p3 != p2


//8.继承和组合